```html
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Spring框架深度解析</title>
    <link href="https://cdn.staticfile.org/tailwindcss/2.2.19/tailwind.min.css" rel="stylesheet">
    <link href="https://cdn.staticfile.org/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
    <link href="https://fonts.googleapis.com/css2?family=Noto+Serif+SC:wght@400;500;600;700&family=Noto+Sans+SC:wght@300;400;500;700&display=swap" rel="stylesheet">
    <script src="https://cdn.jsdelivr.net/npm/mermaid@latest/dist/mermaid.min.js"></script>
    <style>
        :root {
            --primary: #4f46e5;
            --primary-dark: #4338ca;
            --secondary: #10b981;
            --dark: #1e293b;
            --light: #f8fafc;
        }
        body {
            font-family: 'Noto Sans SC', sans-serif;
            line-height: 1.6;
            color: #334155;
            background-color: #f8fafc;
        }
        h1, h2, h3, h4, h5, h6 {
            font-family: 'Noto Serif SC', serif;
            font-weight: 600;
            color: var(--dark);
        }
        .container {
            max-width: 1200px;
            margin: 0 auto;
            padding: 2rem;
        }
        .hero {
            background: linear-gradient(135deg, var(--primary) 0%, var(--primary-dark) 100%);
            color: white;
            padding: 4rem 2rem;
            border-radius: 1rem;
            margin-bottom: 3rem;
            box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1);
        }
        .card {
            background: white;
            border-radius: 0.5rem;
            padding: 1.5rem;
            margin-bottom: 2rem;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
            transition: transform 0.2s, box-shadow 0.2s;
        }
        .card:hover {
            transform: translateY(-4px);
            box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1);
        }
        .badge {
            display: inline-block;
            padding: 0.25rem 0.75rem;
            border-radius: 9999px;
            font-size: 0.75rem;
            font-weight: 600;
            text-transform: uppercase;
            letter-spacing: 0.05em;
        }
        .badge-primary {
            background-color: var(--primary);
            color: white;
        }
        .badge-secondary {
            background-color: var(--secondary);
            color: white;
        }
        .code-block {
            background: #1e293b;
            color: #e2e8f0;
            padding: 1rem;
            border-radius: 0.5rem;
            font-family: monospace;
            overflow-x: auto;
            margin: 1rem 0;
        }
        .diagram-container {
            background: white;
            padding: 1.5rem;
            border-radius: 0.5rem;
            margin: 2rem 0;
            box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
        }
        .feature-icon {
            display: inline-flex;
            align-items: center;
            justify-content: center;
            width: 3rem;
            height: 3rem;
            border-radius: 0.5rem;
            background-color: rgba(79, 70, 229, 0.1);
            color: var(--primary);
            margin-right: 1rem;
        }
        .nav-link {
            color: var(--dark);
            font-weight: 500;
            padding: 0.5rem 1rem;
            border-radius: 0.375rem;
            transition: all 0.2s;
        }
        .nav-link:hover {
            color: var(--primary);
            background-color: rgba(79, 70, 229, 0.1);
        }
        .nav-link.active {
            color: var(--primary);
            background-color: rgba(79, 70, 229, 0.1);
        }
        .sidebar {
            position: sticky;
            top: 2rem;
            align-self: start;
        }
        .sidebar-item {
            padding: 0.5rem 1rem;
            border-left: 3px solid transparent;
            transition: all 0.2s;
        }
        .sidebar-item:hover {
            background-color: rgba(79, 70, 229, 0.05);
            border-left-color: var(--primary);
        }
        .sidebar-item.active {
            background-color: rgba(79, 70, 229, 0.1);
            border-left-color: var(--primary);
            font-weight: 500;
        }
        .highlight {
            background-color: rgba(255, 255, 0, 0.2);
            padding: 0.2rem 0.4rem;
            border-radius: 0.25rem;
        }
    </style>
</head>
<body>
    <div class="container mx-auto">
        <!-- Hero Section -->
        <section class="hero">
            <div class="max-w-3xl mx-auto text-center">
                <h1 class="text-4xl md:text-5xl font-bold mb-4">Spring框架深度解析</h1>
                <p class="text-xl opacity-90 mb-8">简化企业级Java开发的全栈框架</p>
                <div class="flex justify-center space-x-4">
                    <a href="#overview" class="bg-white text-primary px-6 py-2 rounded-full font-medium hover:bg-opacity-90 transition">开始探索</a>
                    <a href="https://spring.io/" target="_blank" class="border-2 border-white text-white px-6 py-2 rounded-full font-medium hover:bg-white hover:bg-opacity-10 transition">官方网站</a>
                </div>
            </div>
        </section>

        <!-- Main Content -->
        <div class="flex flex-col md:flex-row gap-8">
            <!-- Sidebar Navigation -->
            <div class="md:w-1/4 sidebar hidden md:block">
                <div class="bg-white rounded-lg p-4 shadow">
                    <h3 class="font-bold text-lg mb-4 text-dark">目录</h3>
                    <ul class="space-y-2">
                        <li><a href="#overview" class="sidebar-item active">概述</a></li>
                        <li><a href="#ioc" class="sidebar-item">IOC控制反转</a></li>
                        <li><a href="#di" class="sidebar-item">DI依赖注入</a></li>
                        <li><a href="#aop" class="sidebar-item">AOP面向切面</a></li>
                        <li><a href="#transaction" class="sidebar-item">事务管理</a></li>
                        <li><a href="#modules" class="sidebar-item">模块组成</a></li>
                        <li><a href="#why-spring" class="sidebar-item">为什么选择Spring</a></li>
                    </ul>
                </div>
            </div>

            <!-- Content -->
            <div class="md:w-3/4">
                <!-- Overview Section -->
                <section id="overview" class="mb-12">
                    <h2 class="text-3xl font-bold mb-6">Spring概述</h2>
                    <div class="card">
                        <h3 class="text-2xl font-semibold mb-4">简介</h3>
                        <ul class="space-y-3">
                            <li class="flex items-start">
                                <i class="fas fa-leaf text-green-500 mt-1 mr-3"></i>
                                <span>Spring是一个开源框架，翻译过来是春天的意思，给软件行业带来了春天。</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-leaf text-green-500 mt-1 mr-3"></i>
                                <span>Spring为简化企业级开发而生，使用Spring开发可以将Bean对象，Dao组件对象，Service组件对象等交给Spring容器来管理，这样使得很多复杂的代码在Spring中开发却变得非常的优雅和简洁，有效的降低代码的耦合度，极大的方便项目的后期维护、升级和扩展。</span>
                            </li>
                            <li class="flex items-start">
                                <i class="fas fa-leaf text-green-500 mt-1 mr-3"></i>
                                <span>Spring是一个IOC和AOP容器框架。</span>
                            </li>
                        </ul>
                    </div>

                    <div class="card">
                        <h3 class="text-2xl font-semibold mb-4">Spring模块组成</h3>
                        <div class="diagram-container">
                            <div class="mermaid">
                                graph LR
                                A[Spring Framework] --> B[Core Container]
                                A --> C[AOP]
                                A --> D[Data Access/Integration]
                                A --> E[Web]
                                B --> B1[Beans]
                                B --> B2[Core]
                                B --> B3[Context]
                                B --> B4[Expression Language]
                                C --> C1[AOP]
                                C --> C2[Aspects]
                                D --> D1[JDBC]
                                D --> D2[ORM]
                                D --> D3[Transactions]
                                D --> D4[OXM]
                                D --> D5[JMS]
                                E --> E1[Web]
                                E --> E2[Web-MVC]
                                E --> E3[Web-Socket]
                                E --> E4[Portlet]
                            </div>
                        </div>
                        <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mt-4">
                            <div>
                                <h4 class="font-semibold mb-2">Core Container</h4>
                                <ul class="space-y-1">
                                    <li>spring-beans.jar</li>
                                    <li>spring-context.jar</li>
                                    <li>spring-core.jar</li>
                                    <li>spring-expression.jar</li>
                                </ul>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2">AOP</h4>
                                <ul class="space-y-1">
                                    <li>spring-aop.jar</li>
                                    <li>spring-aspects.jar</li>
                                </ul>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2">Data Access</h4>
                                <ul class="space-y-1">
                                    <li>spring-jdbc.jar</li>
                                    <li>spring-orm.jar</li>
                                    <li>spring-tx.jar</li>
                                    <li>spring-oxm.jar</li>
                                    <li>spring-jms.jar</li>
                                </ul>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2">Web</h4>
                                <ul class="space-y-1">
                                    <li>spring-web.jar</li>
                                    <li>spring-webmvc.jar</li>
                                    <li>spring-websocket.jar</li>
                                    <li>spring-webmvc-portlet.jar</li>
                                </ul>
                            </div>
                        </div>
                    </div>
                </section>

                <!-- IOC Section -->
                <section id="ioc" class="mb-12">
                    <h2 class="text-3xl font-bold mb-6">IOC控制反转</h2>
                    <div class="card">
                        <h3 class="text-2xl font-semibold mb-4">什么是IOC?</h3>
                        <p>控制反转：Inverse Of Controll，IOC容器就是具有依赖注入功能的容器，是可以创建对象的容器，IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖，并管理这整个bean的生命周期。</p>
                        <p class="mt-3">通常new一个实例，控制权由程序员控制，而"控制反转"是指new实例工作不由程序员来做而是交给Spring容器来做。</p>
                    </div>

                    <div class="card">
                        <h3 class="text-2xl font-semibold mb-4">IOC解决的问题</h3>
                        <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
                            <div>
                                <h4 class="font-semibold mb-2">强耦合问题</h4>
                                <div class="code-block">
                                    <pre><code>public class UserDaoImpl {
    public void addUse(){
        System.out.println("UserDaoImpl.addUse");
    }
}

public class UserServiceImpl {
    // 硬编码，耦合度高
    private UserDaoImpl userDao = new UserDaoImpl();
    
    public void addUser(){
        userDao.addUse();
    }
}</code></pre>
                                </div>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2">IOC解决方案</h4>
                                <div class="code-block">
                                    <pre><code>// Spring配置
&lt;bean id="userService" class="com.ts.service.impl.UserServiceImpl">
    &lt;property name="userDao" ref="userDao"/>
&lt;/bean>

&lt;bean id="userDao" class="com.ts.dao.impl.UserDaoImpl"/>

// 测试代码
ApplicationContext context = 
    new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = context.getBean("userService", UserService.class);
userService.addUser();</code></pre>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="card">
                        <h3 class="text-2xl font-semibold mb-4">Bean的生命周期</h3>
                        <div class="diagram-container">
                            <div class="mermaid">
                                flowchart TD
                                A[容器启动] --> B[Bean实例化]
                                B --> C[属性赋值]
                                C --> D[BeanPostProcessor前置处理]
                                D --> E[初始化方法init]
                                E --> F[BeanPostProcessor后置处理]
                                F --> G[Bean就绪可用]
                                G --> H[容器关闭]
                                H --> I[销毁方法destroy]
                            </div>
                        </div>
                        <div class="mt-4">
                            <h4 class="font-semibold mb-2">生命周期总结</h4>
                            <ul class="space-y-2">
                                <li><span class="font-medium">单例情况下:</span> 容器创建时初始化，容器关闭时销毁</li>
                                <li><span class="font-medium">多例情况下:</span> 使用时初始化，长期不用后被垃圾回收</li>
                                <li><span class="font-medium">关键点:</span> 单例对象的生命周期与容器相关，多例对象的生命周期与使用情况相关</li>
                            </ul>
                        </div>
                    </div>
                </section>

                <!-- DI Section -->
                <section id="di" class="mb-12">
                    <h2 class="text-3xl font-bold mb-6">DI依赖注入</h2>
                    <div class="card">
                        <h3 class="text-2xl font-semibold mb-4">依赖注入简介</h3>
                        <p>依赖注入：<em>Dependency Injection</em>。它是spring框架核心ioc的具体实现。</p>
                        <p class="mt-3">我们的程序在编写时，通过控制反转，把对象的创建交给了spring，但是代码中不可能出现没有依赖的情况。ioc解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。</p>
                        <p class="mt-3">简单的说，就是让Spring框架把持久层对象传入业务层，而不用我们自己去获取。</p>
                    </div>

                    <div class="card">
                        <h3 class="text-2xl font-semibold mb-4">注入方式</h3>
                        <div class="grid grid-cols-1 md:grid-cols-3 gap-4">
                            <div>
                                <h4 class="font-semibold mb-2 flex items-center">
                                    <i class="fas fa-code-branch mr-2 text-blue-500"></i>构造器注入
                                </h4>
                                <div class="code-block">
                                    <pre><code>&lt;bean class="com.ts.entity.User" id="user2">
    &lt;constructor-arg name="id" value="20"/>
    &lt;constructor-arg name="username" value="admin"/>
&lt;/bean></code></pre>
                                </div>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2 flex items-center">
                                    <i class="fas fa-code mr-2 text-green-500"></i>Setter注入
                                </h4>
                                <div class="code-block">
                                    <pre><code>&lt;bean class="com.ts.entity.User" id="user3">
    &lt;property name="username" value="123"/>
    &lt;property name="id" value="10"/>
&lt;/bean></code></pre>
                                </div>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2 flex items-center">
                                    <i class="fas fa-project-diagram mr-2 text-purple-500"></i>自动注入
                                </h4>
                                <div class="code-block">
                                    <pre><code>&lt;bean id="userService" 
    class="com.ts.service.impl.UserServiceImpl" 
    autowire="byName">
&lt;/bean></code></pre>
                                </div>
                            </div>
                        </div>
                    </div>
                </section>

                <!-- AOP Section -->
                <section id="aop" class="mb-12">
                    <h2 class="text-3xl font-bold mb-6">AOP面向切面编程</h2>
                    <div class="card">
                        <h3 class="text-2xl font-semibold mb-4">AOP概念</h3>
                        <p>AOP（Aspect Orient Programming），直译过来就是面向切面编程。<strong>AOP是一种编程思想</strong>，是面向对象编程（OOP）的一种补充。</p>
                        <p class="mt-3">AOP技术它是利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。</p>
                    </div>

                    <div class="card">
                        <h3 class="text-2xl font-semibold mb-4">AOP术语</h3>
                        <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
                            <div>
                                <div class="flex items-start mb-4">
                                    <div class="feature-icon">
                                        <i class="fas fa-bullseye"></i>
                                    </div>
                                    <div>
                                        <h4 class="font-semibold">通知(Advice)</h4>
                                        <p class="text-gray-600">需要增强的代码，也就是常见的 安全，事物，日志等。</p>
                                    </div>
                                </div>
                                <div class="flex items-start mb-4">
                                    <div class="feature-icon">
                                        <i class="fas fa-link"></i>
                                    </div>
                                    <div>
                                        <h4 class="font-semibold">连接点(JoinPoint)</h4>
                                        <p class="text-gray-600">Spring允许你使用通知的地方，基本每个方法的前、后或抛出异常时都可以是连接点。</p>
                                    </div>
                                </div>
                                <div class="flex items-start">
                                    <div class="feature-icon">
                                        <i class="fas fa-crosshairs"></i>
                                    </div>
                                    <div>
                                        <h4 class="font-semibold">切入点(Pointcut)</h4>
                                        <p class="text-gray-600">已经确定被增强的方法。</p>
                                    </div>
                                </div>
                            </div>
                            <div>
                                <div class="flex items-start mb-4">
                                    <div class="feature-icon">
                                        <i class="fas fa-puzzle-piece"></i>
                                    </div>
                                    <div>
                                        <h4 class="font-semibold">切面(Aspect)</h4>
                                        <p class="text-gray-600">切面是通知和切入点的结合。</p>
                                    </div>
                                </div>
                                <div class="flex items-start mb-4">
                                    <div class="feature-icon">
                                        <i class="fas fa-bullseye"></i>
                                    </div>
                                    <div>
                                        <h4 class="font-semibold">目标对象(Target)</h4>
                                        <p class="text-gray-600">被通知的对象，也就是真正的业务逻辑。</p>
                                    </div>
                                </div>
                                <div class="flex items-start">
                                    <div class="feature-icon">
                                        <i class="fas fa-project-diagram"></i>
                                    </div>
                                    <div>
                                        <h4 class="font-semibold">织入(Weaving)</h4>
                                        <p class="text-gray-600">把切面应用到目标对象来创建新的代理对象的过程。</p>
                                    </div>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="card">
                        <h3 class="text-2xl font-semibold mb-4">AOP通知类型</h3>
                        <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
                            <div>
                                <h4 class="font-semibold mb-2">基于XML配置</h4>
                                <div class="code-block">
                                    <pre><code>&lt;aop:config>
    &lt;aop:pointcut id="p1" 
        expression="execution(* com.ts.service..*.*(..))"/>
    &lt;aop:aspect ref="timeManager">
        &lt;aop:before method="start" pointcut-ref="p1"/>
        &lt;aop:after method="end" pointcut-ref="p1"/>
        &lt;aop:around method="around" pointcut-ref="p1"/>
    &lt;/aop:aspect>
&lt;/aop:config></code></pre>
                                </div>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2">基于注解配置</h4>
                                <div class="code-block">
                                    <pre><code>@Aspect
@Component
public class TimeManager {
    @Pointcut("execution(* com.ts.service.*.*(..))")
    public void p1(){}
    
    @Before("p1()")
    public void start() { ... }
    
    @After("p1()")
    public void end() { ... }
    
    @Around("p1()")
    public Object around(ProceedingJoinPoint pjp) { ... }
}</code></pre>
                                </div>
                            </div>
                        </div>
                    </div>
                </section>

                <!-- Transaction Section -->
                <section id="transaction" class="mb-12">
                    <h2 class="text-3xl font-bold mb-6">事务管理</h2>
                    <div class="card">
                        <h3 class="text-2xl font-semibold mb-4">Spring事务管理方式</h3>
                        <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
                            <div>
                                <h4 class="font-semibold mb-2 flex items-center">
                                    <i class="fas fa-code mr-2 text-blue-500"></i>编程式事务
                                </h4>
                                <div class="code-block">
                                    <pre><code>@Service
public class AccountServiceImpl implements IAccountService {
    @Autowired
    private TransactionTemplate transactionTemplate;
    
    public void transfer() {
        transactionTemplate.execute(status -> {
            accountDao.out(outName, money);
            accountDao.in(inName, money);
            return null;
        });
    }
}</code></pre>
                                </div>
                            </div>
                            <div>
                                <h4 class="font-semibold mb-2 flex items-center">
                                    <i class="fas fa-cog mr-2 text-green-500"></i>声明式事务
                                </h4>
                                <div class="code-block">
                                    <pre><code>// XML配置
&lt;tx:advice id="txAdvice" transaction-manager="txManager">
    &lt;tx:attributes>
        &lt;tx:method name="transfer" propagation="REQUIRED"/>
    &lt;/tx:attributes>
&lt;/tx:advice>

// 注解方式
@Transactional(propagation=Propagation.REQUIRED)
public void transfer() {
    accountDao.out(outName, money);
    accountDao.in(inName, money);
}</code></pre>
                                </div>
                            </div>
                        </div>
                    </div>

                    <div class="card">
                        <h3 class="text-2xl font-semibold mb-4">事务传播行为</h3>
                        <div class="overflow-x-auto">
                            <table class="min-w-full bg-white">
                                <thead>
                                    <tr>
                                        <th class="py-2 px-4 border-b border-gray-200 bg-gray-50 text-left text-xs font-semibold text-gray-600 uppercase tracking-wider">传播行为</th>
                                        <th class="py-2 px-4 border-b border-gray-200 bg-gray-50 text-left text-xs font-semibold text-gray-600 uppercase tracking-wider">说明</th>
                                    </tr>
                                </thead>
                                <tbody>
                                    <tr>
                                        <td class="py-2 px-4 border-b border-gray-200">REQUIRED</td>
                                        <td class="py-2 px-4 border-b border-gray-200">支持当前事务，如果不存在则创建一个新事务</td>
                                    </tr>
                                    <tr>
                                        <td class="py-2 px-4 border-b border-gray-200">SUPPORTS</td>
                                        <td class="py-2 px-4 border-b border-gray-200">支持当前事务，如果不存在则以非事务方式执行</td>
                                    </tr>
                                    <tr>
                                        <td class="py-2 px-4 border-b border-gray-200">MANDATORY</td>
                                        <td class="py-2 px-4 border-b border-gray-200">支持当前事务，如果不存在则抛出异常</td>
                                    </tr>
                                    <tr>
                                        <td class="py-2 px-4 border-b border-gray-200">REQUIRES_NEW</td>
                                        <td class="py-2 px-4 border-b border-gray-200">创建一个新事务，如果存在当前事务则挂起</td>
                                    </tr>
                                    <tr>
                                        <td class="py-2 px-4 border-b border-gray-200">NOT_SUPPORTED</td>
                                        <td class="py-2 px-4 border-b border-gray-200">以非事务方式执行，如果存在当前事务则挂起</td>
                                    </tr>
                                    <tr>
                                        <td class="py-2 px-4 border-b border-gray-200">NEVER</td>
                                        <td class="py-2 px-4 border-b border-gray-200">以非事务方式执行，如果存在事务则抛出异常</td>
                                    </tr>
                                    <tr>
                                        <td class="py-2 px-4 border-b border-gray-200">NESTED</td>
                                        <td class="py-2 px-4 border-b border-gray-200">如果存在当前事务，则在嵌套事务内执行</td>
                                    </tr>
                                </tbody>
                            </table>
                        </div>
                    </div>
                </section>

                <!-- Why Spring Section -->
                <section id="why-spring" class="mb-12">
                    <h2 class="text-3xl font-bold mb-6">为什么选择Spring?</h2>
                    <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
                        <div class="card">
                            <h3 class="text-2xl font-semibold mb-4">Spring解决的问题</h3>
                            <ul class="space-y-3">
                                <li class="flex items-start">
                                    <i class="fas fa-check-circle text-green-500 mt-1 mr-3"></i>
                                    <span>面向接口编程的实例化对象</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-check-circle text-green-500 mt-1 mr-3"></i>
                                    <span>多个业务类之间耦合</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-check-circle text-green-500 mt-1 mr-3"></i>
                                    <span>对象的生命周期无法得到统一的管理</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-check-circle text-green-500 mt-1 mr-3"></i>
                                    <span>对象的单例模式需要自己维护</span>
                                </li>
                            </ul>
                        </div>
                        <div class="card">
                            <h3 class="text-2xl font-semibold mb-4">Spring的优势</h3>
                            <ul class="space-y-3">
                                <li class="flex items-start">
                                    <i class="fas fa-star text-yellow-500 mt-1 mr-3"></i>
                                    <span><span class="font-medium">非侵入式:</span> 基于Spring开发的应用中的对象可以不依赖于Spring的API</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-star text-yellow-500 mt-1 mr-3"></i>
                                    <span><span class="font-medium">控制反转:</span> IOC——Inversion of Control，指的是将对象的创建权交给Spring去创建</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-star text-yellow-500 mt-1 mr-3"></i>
                                    <span><span class="font-medium">依赖注入:</span> DI——Dependency Injection，是指依赖的对象不需要手动调用setXX方法去设置</span>
                                </li>
                                <li class="flex items-start">
                                    <i class="fas fa-star text-yellow-500 mt-1 mr-3"></i>
                                    <span><span class="font-medium">面向切面编程:</span> Aspect Oriented Programming——AOP</span>
                                </li>
                            </ul>
                        </div>
                    </div>
                </section>
            </div>
        </div>
    </div>

    <script>
        mermaid.initialize({
            startOnLoad: true,
            theme: 'default',
            flowchart: {
                useMaxWidth: true,
                htmlLabels: true,
                curve: 'basis'
            }
        });
    </script>
</body>
</html>
```